// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.inventory.real;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.InventoryReal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(InventoryReal.class)
@Setter
@Getter
public class InventoryRealSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "InventoryReal".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("stockId", "w");
    map.put("sku", "p");
    map.put("product", "p2");
    map.put("shop", "si");
    map.put("itemId", "p");
    map.put("tradeName", "p2");
    map.put("shopId", "si");
    map.put("wareHouse", "w2");
    map.put("listingHead", "lf");
    map.put("spu", "p3");
    map.put("pos", "wb");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 仓库内码
   */
  private Long stockId;

  /**
   * 仓库内码 比较(eq)
   */
  private Long stockIdEq;
  /**
   * 仓库内码 比较(neq)
   */
  private Long stockIdNeq;
  /**
   * 仓库内码 比较(gt)
   */
  private Long stockIdGt;
  /**
   * 仓库内码 比较(gte)
   */
  private Long stockIdGte;
  /**
   * 仓库内码 比较(lt)
   */
  private Long stockIdLt;
  /**
   * 仓库内码 比较(lte)
   */
  private Long stockIdLte;
  /**
   * 仓库内码 比较(contains)
   */
  private Long stockIdContains;
  /**
   * 仓库内码 比较(notcontains)
   */
  private Long stockIdNotcontains;
  /**
   * 仓库内码 比较(startswith)
   */
  private Long stockIdStartswith;
  /**
   * 仓库内码 比较(endswith)
   */
  private Long stockIdEndswith;
  /**
   * 仓库内码 比较(isnull)
   */
  private Boolean stockIdIsnull;
  /**
   * 仓库内码 比较(isnotnull)
   */
  private Boolean stockIdIsnotnull;
  /**
   * 仓库内码的仓库名称 比较(eq)
   */
  private String stockIdNameEq;
  /**
   * 仓库内码的仓库名称 比较(neq)
   */
  private String stockIdNameNeq;
  /**
   * 仓库内码的仓库名称 比较(gt)
   */
  private String stockIdNameGt;
  /**
   * 仓库内码的仓库名称 比较(gte)
   */
  private String stockIdNameGte;
  /**
   * 仓库内码的仓库名称 比较(lt)
   */
  private String stockIdNameLt;
  /**
   * 仓库内码的仓库名称 比较(lte)
   */
  private String stockIdNameLte;
  /**
   * 仓库内码的仓库名称 比较(contains)
   */
  private String stockIdNameContains;
  /**
   * 仓库内码的仓库名称 比较(notcontains)
   */
  private String stockIdNameNotcontains;
  /**
   * 仓库内码的仓库名称 比较(startswith)
   */
  private String stockIdNameStartswith;
  /**
   * 仓库内码的仓库名称 比较(endswith)
   */
  private String stockIdNameEndswith;
  /**
   * 仓库内码的仓库名称 比较(isnull)
   */
  private Boolean stockIdNameIsnull;
  /**
   * 仓库内码的仓库名称 比较(isnotnull)
   */
  private Boolean stockIdNameIsnotnull;

  /**
   * 仓库内码(范围搜索)
   */
  private List<Long> stockIdInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnSku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnSkuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnSkuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnSkuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnSkuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnSkuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnSkuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnSkuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnSkuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnSkuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnSkuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnSkuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnSkuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnSkuInList;

  /**
   * 项目内码
   */
  private Long projectId;

  /**
   * 最小项目内码
   */
  private Long projectIdMin;

  /**
   * 最大项目内码
   */
  private Long projectIdMax;

  /**
   * 项目内码 比较(eq)
   */
  private Long projectIdEq;
  /**
   * 项目内码 比较(neq)
   */
  private Long projectIdNeq;
  /**
   * 项目内码 比较(gt)
   */
  private Long projectIdGt;
  /**
   * 项目内码 比较(gte)
   */
  private Long projectIdGte;
  /**
   * 项目内码 比较(lt)
   */
  private Long projectIdLt;
  /**
   * 项目内码 比较(lte)
   */
  private Long projectIdLte;
  /**
   * 项目内码 比较(contains)
   */
  private Long projectIdContains;
  /**
   * 项目内码 比较(notcontains)
   */
  private Long projectIdNotcontains;
  /**
   * 项目内码 比较(startswith)
   */
  private Long projectIdStartswith;
  /**
   * 项目内码 比较(endswith)
   */
  private Long projectIdEndswith;
  /**
   * 项目内码 比较(isnull)
   */
  private Boolean projectIdIsnull;
  /**
   * 项目内码 比较(isnotnull)
   */
  private Boolean projectIdIsnotnull;

  /**
   * 物料内码
   */
  private Long itemId;

  /**
   * 物料内码 比较(eq)
   */
  private Long itemIdEq;
  /**
   * 物料内码 比较(neq)
   */
  private Long itemIdNeq;
  /**
   * 物料内码 比较(gt)
   */
  private Long itemIdGt;
  /**
   * 物料内码 比较(gte)
   */
  private Long itemIdGte;
  /**
   * 物料内码 比较(lt)
   */
  private Long itemIdLt;
  /**
   * 物料内码 比较(lte)
   */
  private Long itemIdLte;
  /**
   * 物料内码 比较(contains)
   */
  private Long itemIdContains;
  /**
   * 物料内码 比较(notcontains)
   */
  private Long itemIdNotcontains;
  /**
   * 物料内码 比较(startswith)
   */
  private Long itemIdStartswith;
  /**
   * 物料内码 比较(endswith)
   */
  private Long itemIdEndswith;
  /**
   * 物料内码 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 物料内码 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;
  /**
   * 物料内码的品名 比较(eq)
   */
  private String itemIdNameEq;
  /**
   * 物料内码的品名 比较(neq)
   */
  private String itemIdNameNeq;
  /**
   * 物料内码的品名 比较(gt)
   */
  private String itemIdNameGt;
  /**
   * 物料内码的品名 比较(gte)
   */
  private String itemIdNameGte;
  /**
   * 物料内码的品名 比较(lt)
   */
  private String itemIdNameLt;
  /**
   * 物料内码的品名 比较(lte)
   */
  private String itemIdNameLte;
  /**
   * 物料内码的品名 比较(contains)
   */
  private String itemIdNameContains;
  /**
   * 物料内码的品名 比较(notcontains)
   */
  private String itemIdNameNotcontains;
  /**
   * 物料内码的品名 比较(startswith)
   */
  private String itemIdNameStartswith;
  /**
   * 物料内码的品名 比较(endswith)
   */
  private String itemIdNameEndswith;
  /**
   * 物料内码的品名 比较(isnull)
   */
  private Boolean itemIdNameIsnull;
  /**
   * 物料内码的品名 比较(isnotnull)
   */
  private Boolean itemIdNameIsnotnull;

  /**
   * 物料内码(范围搜索)
   */
  private List<Long> itemIdInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 批号(模糊搜索)
   */
  private String batchNo;

  /**
   * 批号 比较(eq)
   */
  private String batchNoEq;
  /**
   * 批号 比较(neq)
   */
  private String batchNoNeq;
  /**
   * 批号 比较(gt)
   */
  private String batchNoGt;
  /**
   * 批号 比较(gte)
   */
  private String batchNoGte;
  /**
   * 批号 比较(lt)
   */
  private String batchNoLt;
  /**
   * 批号 比较(lte)
   */
  private String batchNoLte;
  /**
   * 批号 比较(contains)
   */
  private String batchNoContains;
  /**
   * 批号 比较(notcontains)
   */
  private String batchNoNotcontains;
  /**
   * 批号 比较(startswith)
   */
  private String batchNoStartswith;
  /**
   * 批号 比较(endswith)
   */
  private String batchNoEndswith;
  /**
   * 批号 比较(isnull)
   */
  private Boolean batchNoIsnull;
  /**
   * 批号 比较(isnotnull)
   */
  private Boolean batchNoIsnotnull;

  /**
   * 批号(精确搜索)
   */
  private List<String> batchNoInList;

  /**
   * 保质期(天)
   */
  private Integer shelfLife;

  /**
   * 最小保质期(天)
   */
  private Integer shelfLifeMin;

  /**
   * 最大保质期(天)
   */
  private Integer shelfLifeMax;

  /**
   * 保质期(天) 比较(eq)
   */
  private Integer shelfLifeEq;
  /**
   * 保质期(天) 比较(neq)
   */
  private Integer shelfLifeNeq;
  /**
   * 保质期(天) 比较(gt)
   */
  private Integer shelfLifeGt;
  /**
   * 保质期(天) 比较(gte)
   */
  private Integer shelfLifeGte;
  /**
   * 保质期(天) 比较(lt)
   */
  private Integer shelfLifeLt;
  /**
   * 保质期(天) 比较(lte)
   */
  private Integer shelfLifeLte;
  /**
   * 保质期(天) 比较(contains)
   */
  private Integer shelfLifeContains;
  /**
   * 保质期(天) 比较(notcontains)
   */
  private Integer shelfLifeNotcontains;
  /**
   * 保质期(天) 比较(startswith)
   */
  private Integer shelfLifeStartswith;
  /**
   * 保质期(天) 比较(endswith)
   */
  private Integer shelfLifeEndswith;
  /**
   * 保质期(天) 比较(isnull)
   */
  private Boolean shelfLifeIsnull;
  /**
   * 保质期(天) 比较(isnotnull)
   */
  private Boolean shelfLifeIsnotnull;

  /**
   * 最早生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateStart;

  /**
   * 最晚生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateEnd;

  /**
   * 生产日期 比较(eq)
   */
  private Date productionDateEq;
  /**
   * 生产日期 比较(neq)
   */
  private Date productionDateNeq;
  /**
   * 生产日期 比较(gt)
   */
  private Date productionDateGt;
  /**
   * 生产日期 比较(gte)
   */
  private Date productionDateGte;
  /**
   * 生产日期 比较(lt)
   */
  private Date productionDateLt;
  /**
   * 生产日期 比较(lte)
   */
  private Date productionDateLte;
  /**
   * 生产日期 比较(contains)
   */
  private Date productionDateContains;
  /**
   * 生产日期 比较(notcontains)
   */
  private Date productionDateNotcontains;
  /**
   * 生产日期 比较(startswith)
   */
  private Date productionDateStartswith;
  /**
   * 生产日期 比较(endswith)
   */
  private Date productionDateEndswith;
  /**
   * 生产日期 比较(isnull)
   */
  private Boolean productionDateIsnull;
  /**
   * 生产日期 比较(isnotnull)
   */
  private Boolean productionDateIsnotnull;

  /**
   * 最早有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateStart;

  /**
   * 最晚有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateEnd;

  /**
   * 有效期至 比较(eq)
   */
  private Date expiryDateEq;
  /**
   * 有效期至 比较(neq)
   */
  private Date expiryDateNeq;
  /**
   * 有效期至 比较(gt)
   */
  private Date expiryDateGt;
  /**
   * 有效期至 比较(gte)
   */
  private Date expiryDateGte;
  /**
   * 有效期至 比较(lt)
   */
  private Date expiryDateLt;
  /**
   * 有效期至 比较(lte)
   */
  private Date expiryDateLte;
  /**
   * 有效期至 比较(contains)
   */
  private Date expiryDateContains;
  /**
   * 有效期至 比较(notcontains)
   */
  private Date expiryDateNotcontains;
  /**
   * 有效期至 比较(startswith)
   */
  private Date expiryDateStartswith;
  /**
   * 有效期至 比较(endswith)
   */
  private Date expiryDateEndswith;
  /**
   * 有效期至 比较(isnull)
   */
  private Boolean expiryDateIsnull;
  /**
   * 有效期至 比较(isnotnull)
   */
  private Boolean expiryDateIsnotnull;

  /**
   * 库存数量
   */
  private Long stockQty;

  /**
   * 最小库存数量
   */
  private Long stockQtyMin;

  /**
   * 最大库存数量
   */
  private Long stockQtyMax;

  /**
   * 库存数量 比较(eq)
   */
  private Long stockQtyEq;
  /**
   * 库存数量 比较(neq)
   */
  private Long stockQtyNeq;
  /**
   * 库存数量 比较(gt)
   */
  private Long stockQtyGt;
  /**
   * 库存数量 比较(gte)
   */
  private Long stockQtyGte;
  /**
   * 库存数量 比较(lt)
   */
  private Long stockQtyLt;
  /**
   * 库存数量 比较(lte)
   */
  private Long stockQtyLte;
  /**
   * 库存数量 比较(contains)
   */
  private Long stockQtyContains;
  /**
   * 库存数量 比较(notcontains)
   */
  private Long stockQtyNotcontains;
  /**
   * 库存数量 比较(startswith)
   */
  private Long stockQtyStartswith;
  /**
   * 库存数量 比较(endswith)
   */
  private Long stockQtyEndswith;
  /**
   * 库存数量 比较(isnull)
   */
  private Boolean stockQtyIsnull;
  /**
   * 库存数量 比较(isnotnull)
   */
  private Boolean stockQtyIsnotnull;

  /**
   * 库存金额
   */
  private java.math.BigDecimal stockAmount;

  /**
   * 最小库存金额
   */
  private java.math.BigDecimal stockAmountMin;

  /**
   * 最大库存金额
   */
  private java.math.BigDecimal stockAmountMax;

  /**
   * 库存金额 比较(eq)
   */
  private java.math.BigDecimal stockAmountEq;
  /**
   * 库存金额 比较(neq)
   */
  private java.math.BigDecimal stockAmountNeq;
  /**
   * 库存金额 比较(gt)
   */
  private java.math.BigDecimal stockAmountGt;
  /**
   * 库存金额 比较(gte)
   */
  private java.math.BigDecimal stockAmountGte;
  /**
   * 库存金额 比较(lt)
   */
  private java.math.BigDecimal stockAmountLt;
  /**
   * 库存金额 比较(lte)
   */
  private java.math.BigDecimal stockAmountLte;
  /**
   * 库存金额 比较(contains)
   */
  private java.math.BigDecimal stockAmountContains;
  /**
   * 库存金额 比较(notcontains)
   */
  private java.math.BigDecimal stockAmountNotcontains;
  /**
   * 库存金额 比较(startswith)
   */
  private java.math.BigDecimal stockAmountStartswith;
  /**
   * 库存金额 比较(endswith)
   */
  private java.math.BigDecimal stockAmountEndswith;
  /**
   * 库存金额 比较(isnull)
   */
  private Boolean stockAmountIsnull;
  /**
   * 库存金额 比较(isnotnull)
   */
  private Boolean stockAmountIsnotnull;

  /**
   * 辅助计量内码
   */
  private Integer auxId;

  /**
   * 最小辅助计量内码
   */
  private Integer auxIdMin;

  /**
   * 最大辅助计量内码
   */
  private Integer auxIdMax;

  /**
   * 辅助计量内码 比较(eq)
   */
  private Integer auxIdEq;
  /**
   * 辅助计量内码 比较(neq)
   */
  private Integer auxIdNeq;
  /**
   * 辅助计量内码 比较(gt)
   */
  private Integer auxIdGt;
  /**
   * 辅助计量内码 比较(gte)
   */
  private Integer auxIdGte;
  /**
   * 辅助计量内码 比较(lt)
   */
  private Integer auxIdLt;
  /**
   * 辅助计量内码 比较(lte)
   */
  private Integer auxIdLte;
  /**
   * 辅助计量内码 比较(contains)
   */
  private Integer auxIdContains;
  /**
   * 辅助计量内码 比较(notcontains)
   */
  private Integer auxIdNotcontains;
  /**
   * 辅助计量内码 比较(startswith)
   */
  private Integer auxIdStartswith;
  /**
   * 辅助计量内码 比较(endswith)
   */
  private Integer auxIdEndswith;
  /**
   * 辅助计量内码 比较(isnull)
   */
  private Boolean auxIdIsnull;
  /**
   * 辅助计量内码 比较(isnotnull)
   */
  private Boolean auxIdIsnotnull;

  /**
   * 辅助数量
   */
  private java.math.BigDecimal auxQty;

  /**
   * 最小辅助数量
   */
  private java.math.BigDecimal auxQtyMin;

  /**
   * 最大辅助数量
   */
  private java.math.BigDecimal auxQtyMax;

  /**
   * 辅助数量 比较(eq)
   */
  private java.math.BigDecimal auxQtyEq;
  /**
   * 辅助数量 比较(neq)
   */
  private java.math.BigDecimal auxQtyNeq;
  /**
   * 辅助数量 比较(gt)
   */
  private java.math.BigDecimal auxQtyGt;
  /**
   * 辅助数量 比较(gte)
   */
  private java.math.BigDecimal auxQtyGte;
  /**
   * 辅助数量 比较(lt)
   */
  private java.math.BigDecimal auxQtyLt;
  /**
   * 辅助数量 比较(lte)
   */
  private java.math.BigDecimal auxQtyLte;
  /**
   * 辅助数量 比较(contains)
   */
  private java.math.BigDecimal auxQtyContains;
  /**
   * 辅助数量 比较(notcontains)
   */
  private java.math.BigDecimal auxQtyNotcontains;
  /**
   * 辅助数量 比较(startswith)
   */
  private java.math.BigDecimal auxQtyStartswith;
  /**
   * 辅助数量 比较(endswith)
   */
  private java.math.BigDecimal auxQtyEndswith;
  /**
   * 辅助数量 比较(isnull)
   */
  private Boolean auxQtyIsnull;
  /**
   * 辅助数量 比较(isnotnull)
   */
  private Boolean auxQtyIsnotnull;

  /**
   * 锁库数量
   */
  private java.math.BigDecimal lockQty;

  /**
   * 最小锁库数量
   */
  private java.math.BigDecimal lockQtyMin;

  /**
   * 最大锁库数量
   */
  private java.math.BigDecimal lockQtyMax;

  /**
   * 锁库数量 比较(eq)
   */
  private java.math.BigDecimal lockQtyEq;
  /**
   * 锁库数量 比较(neq)
   */
  private java.math.BigDecimal lockQtyNeq;
  /**
   * 锁库数量 比较(gt)
   */
  private java.math.BigDecimal lockQtyGt;
  /**
   * 锁库数量 比较(gte)
   */
  private java.math.BigDecimal lockQtyGte;
  /**
   * 锁库数量 比较(lt)
   */
  private java.math.BigDecimal lockQtyLt;
  /**
   * 锁库数量 比较(lte)
   */
  private java.math.BigDecimal lockQtyLte;
  /**
   * 锁库数量 比较(contains)
   */
  private java.math.BigDecimal lockQtyContains;
  /**
   * 锁库数量 比较(notcontains)
   */
  private java.math.BigDecimal lockQtyNotcontains;
  /**
   * 锁库数量 比较(startswith)
   */
  private java.math.BigDecimal lockQtyStartswith;
  /**
   * 锁库数量 比较(endswith)
   */
  private java.math.BigDecimal lockQtyEndswith;
  /**
   * 锁库数量 比较(isnull)
   */
  private Boolean lockQtyIsnull;
  /**
   * 锁库数量 比较(isnotnull)
   */
  private Boolean lockQtyIsnotnull;

  /**
   * 陈列数量
   */
  private java.math.BigDecimal displayQty;

  /**
   * 最小陈列数量
   */
  private java.math.BigDecimal displayQtyMin;

  /**
   * 最大陈列数量
   */
  private java.math.BigDecimal displayQtyMax;

  /**
   * 陈列数量 比较(eq)
   */
  private java.math.BigDecimal displayQtyEq;
  /**
   * 陈列数量 比较(neq)
   */
  private java.math.BigDecimal displayQtyNeq;
  /**
   * 陈列数量 比较(gt)
   */
  private java.math.BigDecimal displayQtyGt;
  /**
   * 陈列数量 比较(gte)
   */
  private java.math.BigDecimal displayQtyGte;
  /**
   * 陈列数量 比较(lt)
   */
  private java.math.BigDecimal displayQtyLt;
  /**
   * 陈列数量 比较(lte)
   */
  private java.math.BigDecimal displayQtyLte;
  /**
   * 陈列数量 比较(contains)
   */
  private java.math.BigDecimal displayQtyContains;
  /**
   * 陈列数量 比较(notcontains)
   */
  private java.math.BigDecimal displayQtyNotcontains;
  /**
   * 陈列数量 比较(startswith)
   */
  private java.math.BigDecimal displayQtyStartswith;
  /**
   * 陈列数量 比较(endswith)
   */
  private java.math.BigDecimal displayQtyEndswith;
  /**
   * 陈列数量 比较(isnull)
   */
  private Boolean displayQtyIsnull;
  /**
   * 陈列数量 比较(isnotnull)
   */
  private Boolean displayQtyIsnotnull;

  /**
   * 残次数量
   */
  private java.math.BigDecimal defectQty;

  /**
   * 最小残次数量
   */
  private java.math.BigDecimal defectQtyMin;

  /**
   * 最大残次数量
   */
  private java.math.BigDecimal defectQtyMax;

  /**
   * 残次数量 比较(eq)
   */
  private java.math.BigDecimal defectQtyEq;
  /**
   * 残次数量 比较(neq)
   */
  private java.math.BigDecimal defectQtyNeq;
  /**
   * 残次数量 比较(gt)
   */
  private java.math.BigDecimal defectQtyGt;
  /**
   * 残次数量 比较(gte)
   */
  private java.math.BigDecimal defectQtyGte;
  /**
   * 残次数量 比较(lt)
   */
  private java.math.BigDecimal defectQtyLt;
  /**
   * 残次数量 比较(lte)
   */
  private java.math.BigDecimal defectQtyLte;
  /**
   * 残次数量 比较(contains)
   */
  private java.math.BigDecimal defectQtyContains;
  /**
   * 残次数量 比较(notcontains)
   */
  private java.math.BigDecimal defectQtyNotcontains;
  /**
   * 残次数量 比较(startswith)
   */
  private java.math.BigDecimal defectQtyStartswith;
  /**
   * 残次数量 比较(endswith)
   */
  private java.math.BigDecimal defectQtyEndswith;
  /**
   * 残次数量 比较(isnull)
   */
  private Boolean defectQtyIsnull;
  /**
   * 残次数量 比较(isnotnull)
   */
  private Boolean defectQtyIsnotnull;

  /**
   * 在途数量
   */
  private java.math.BigDecimal wayQty;

  /**
   * 最小在途数量
   */
  private java.math.BigDecimal wayQtyMin;

  /**
   * 最大在途数量
   */
  private java.math.BigDecimal wayQtyMax;

  /**
   * 在途数量 比较(eq)
   */
  private java.math.BigDecimal wayQtyEq;
  /**
   * 在途数量 比较(neq)
   */
  private java.math.BigDecimal wayQtyNeq;
  /**
   * 在途数量 比较(gt)
   */
  private java.math.BigDecimal wayQtyGt;
  /**
   * 在途数量 比较(gte)
   */
  private java.math.BigDecimal wayQtyGte;
  /**
   * 在途数量 比较(lt)
   */
  private java.math.BigDecimal wayQtyLt;
  /**
   * 在途数量 比较(lte)
   */
  private java.math.BigDecimal wayQtyLte;
  /**
   * 在途数量 比较(contains)
   */
  private java.math.BigDecimal wayQtyContains;
  /**
   * 在途数量 比较(notcontains)
   */
  private java.math.BigDecimal wayQtyNotcontains;
  /**
   * 在途数量 比较(startswith)
   */
  private java.math.BigDecimal wayQtyStartswith;
  /**
   * 在途数量 比较(endswith)
   */
  private java.math.BigDecimal wayQtyEndswith;
  /**
   * 在途数量 比较(isnull)
   */
  private Boolean wayQtyIsnull;
  /**
   * 在途数量 比较(isnotnull)
   */
  private Boolean wayQtyIsnotnull;

  /**
   * 数据版本
   */
  private Integer version;

  /**
   * 最小数据版本
   */
  private Integer versionMin;

  /**
   * 最大数据版本
   */
  private Integer versionMax;

  /**
   * 数据版本 比较(eq)
   */
  private Integer versionEq;
  /**
   * 数据版本 比较(neq)
   */
  private Integer versionNeq;
  /**
   * 数据版本 比较(gt)
   */
  private Integer versionGt;
  /**
   * 数据版本 比较(gte)
   */
  private Integer versionGte;
  /**
   * 数据版本 比较(lt)
   */
  private Integer versionLt;
  /**
   * 数据版本 比较(lte)
   */
  private Integer versionLte;
  /**
   * 数据版本 比较(contains)
   */
  private Integer versionContains;
  /**
   * 数据版本 比较(notcontains)
   */
  private Integer versionNotcontains;
  /**
   * 数据版本 比较(startswith)
   */
  private Integer versionStartswith;
  /**
   * 数据版本 比较(endswith)
   */
  private Integer versionEndswith;
  /**
   * 数据版本 比较(isnull)
   */
  private Boolean versionIsnull;
  /**
   * 数据版本 比较(isnotnull)
   */
  private Boolean versionIsnotnull;

  /**
   * 品名
   */
  private Long tradeName;

  /**
   * 品名 比较(eq)
   */
  private Long tradeNameEq;
  /**
   * 品名 比较(neq)
   */
  private Long tradeNameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long tradeNameGt;
  /**
   * 品名 比较(gte)
   */
  private Long tradeNameGte;
  /**
   * 品名 比较(lt)
   */
  private Long tradeNameLt;
  /**
   * 品名 比较(lte)
   */
  private Long tradeNameLte;
  /**
   * 品名 比较(contains)
   */
  private Long tradeNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long tradeNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long tradeNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long tradeNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean tradeNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean tradeNameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String tradeNameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String tradeNameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String tradeNameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String tradeNameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String tradeNameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String tradeNameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String tradeNameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String tradeNameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String tradeNameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String tradeNameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean tradeNameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean tradeNameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> tradeNameInList;

  /**
   * 产品标签(模糊搜索)
   */
  private String prdLabel;

  /**
   * 产品标签 比较(eq)
   */
  private String prdLabelEq;
  /**
   * 产品标签 比较(neq)
   */
  private String prdLabelNeq;
  /**
   * 产品标签 比较(gt)
   */
  private String prdLabelGt;
  /**
   * 产品标签 比较(gte)
   */
  private String prdLabelGte;
  /**
   * 产品标签 比较(lt)
   */
  private String prdLabelLt;
  /**
   * 产品标签 比较(lte)
   */
  private String prdLabelLte;
  /**
   * 产品标签 比较(contains)
   */
  private String prdLabelContains;
  /**
   * 产品标签 比较(notcontains)
   */
  private String prdLabelNotcontains;
  /**
   * 产品标签 比较(startswith)
   */
  private String prdLabelStartswith;
  /**
   * 产品标签 比较(endswith)
   */
  private String prdLabelEndswith;
  /**
   * 产品标签 比较(isnull)
   */
  private Boolean prdLabelIsnull;
  /**
   * 产品标签 比较(isnotnull)
   */
  private Boolean prdLabelIsnotnull;

  /**
   * 产品标签(精确搜索)
   */
  private List<String> prdLabelInList;

  /**
   * 产品类型(模糊搜索)
   */
  private String productType;

  /**
   * 产品类型 比较(eq)
   */
  private String productTypeEq;
  /**
   * 产品类型 比较(neq)
   */
  private String productTypeNeq;
  /**
   * 产品类型 比较(gt)
   */
  private String productTypeGt;
  /**
   * 产品类型 比较(gte)
   */
  private String productTypeGte;
  /**
   * 产品类型 比较(lt)
   */
  private String productTypeLt;
  /**
   * 产品类型 比较(lte)
   */
  private String productTypeLte;
  /**
   * 产品类型 比较(contains)
   */
  private String productTypeContains;
  /**
   * 产品类型 比较(notcontains)
   */
  private String productTypeNotcontains;
  /**
   * 产品类型 比较(startswith)
   */
  private String productTypeStartswith;
  /**
   * 产品类型 比较(endswith)
   */
  private String productTypeEndswith;
  /**
   * 产品类型 比较(isnull)
   */
  private Boolean productTypeIsnull;
  /**
   * 产品类型 比较(isnotnull)
   */
  private Boolean productTypeIsnotnull;

  /**
   * 产品类型(精确搜索)
   */
  private List<String> productTypeInList;

  /**
   * 产品状态(模糊搜索)
   */
  private String productStatus;

  /**
   * 产品状态 比较(eq)
   */
  private String productStatusEq;
  /**
   * 产品状态 比较(neq)
   */
  private String productStatusNeq;
  /**
   * 产品状态 比较(gt)
   */
  private String productStatusGt;
  /**
   * 产品状态 比较(gte)
   */
  private String productStatusGte;
  /**
   * 产品状态 比较(lt)
   */
  private String productStatusLt;
  /**
   * 产品状态 比较(lte)
   */
  private String productStatusLte;
  /**
   * 产品状态 比较(contains)
   */
  private String productStatusContains;
  /**
   * 产品状态 比较(notcontains)
   */
  private String productStatusNotcontains;
  /**
   * 产品状态 比较(startswith)
   */
  private String productStatusStartswith;
  /**
   * 产品状态 比较(endswith)
   */
  private String productStatusEndswith;
  /**
   * 产品状态 比较(isnull)
   */
  private Boolean productStatusIsnull;
  /**
   * 产品状态 比较(isnotnull)
   */
  private Boolean productStatusIsnotnull;

  /**
   * 产品状态(精确搜索)
   */
  private List<String> productStatusInList;

  /**
   * 店铺
   */
  private Long shopId;

  /**
   * 店铺 比较(eq)
   */
  private Long shopIdEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopIdNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopIdGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopIdGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopIdLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopIdLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopIdContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopIdNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopIdStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopIdEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopIdShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopIdShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopIdShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopIdShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopIdShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopIdShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopIdShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopIdShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopIdShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopIdShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopIdShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopIdShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopIdInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * 仓库
   */
  private Long wareHouse;

  /**
   * 仓库 比较(eq)
   */
  private Long wareHouseEq;
  /**
   * 仓库 比较(neq)
   */
  private Long wareHouseNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long wareHouseGt;
  /**
   * 仓库 比较(gte)
   */
  private Long wareHouseGte;
  /**
   * 仓库 比较(lt)
   */
  private Long wareHouseLt;
  /**
   * 仓库 比较(lte)
   */
  private Long wareHouseLte;
  /**
   * 仓库 比较(contains)
   */
  private Long wareHouseContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long wareHouseNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long wareHouseStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long wareHouseEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean wareHouseIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean wareHouseIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String wareHouseNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String wareHouseNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String wareHouseNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String wareHouseNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String wareHouseNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String wareHouseNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String wareHouseNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String wareHouseNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String wareHouseNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String wareHouseNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean wareHouseNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean wareHouseNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> wareHouseInList;

  /**
   * Listing负责人
   */
  private Long listingHead;

  /**
   * Listing负责人 比较(eq)
   */
  private Long listingHeadEq;
  /**
   * Listing负责人 比较(neq)
   */
  private Long listingHeadNeq;
  /**
   * Listing负责人 比较(gt)
   */
  private Long listingHeadGt;
  /**
   * Listing负责人 比较(gte)
   */
  private Long listingHeadGte;
  /**
   * Listing负责人 比较(lt)
   */
  private Long listingHeadLt;
  /**
   * Listing负责人 比较(lte)
   */
  private Long listingHeadLte;
  /**
   * Listing负责人 比较(contains)
   */
  private Long listingHeadContains;
  /**
   * Listing负责人 比较(notcontains)
   */
  private Long listingHeadNotcontains;
  /**
   * Listing负责人 比较(startswith)
   */
  private Long listingHeadStartswith;
  /**
   * Listing负责人 比较(endswith)
   */
  private Long listingHeadEndswith;
  /**
   * Listing负责人 比较(isnull)
   */
  private Boolean listingHeadIsnull;
  /**
   * Listing负责人 比较(isnotnull)
   */
  private Boolean listingHeadIsnotnull;
  /**
   * Listing负责人的FNSKU 比较(eq)
   */
  private String listingHeadFnskuEq;
  /**
   * Listing负责人的FNSKU 比较(neq)
   */
  private String listingHeadFnskuNeq;
  /**
   * Listing负责人的FNSKU 比较(gt)
   */
  private String listingHeadFnskuGt;
  /**
   * Listing负责人的FNSKU 比较(gte)
   */
  private String listingHeadFnskuGte;
  /**
   * Listing负责人的FNSKU 比较(lt)
   */
  private String listingHeadFnskuLt;
  /**
   * Listing负责人的FNSKU 比较(lte)
   */
  private String listingHeadFnskuLte;
  /**
   * Listing负责人的FNSKU 比较(contains)
   */
  private String listingHeadFnskuContains;
  /**
   * Listing负责人的FNSKU 比较(notcontains)
   */
  private String listingHeadFnskuNotcontains;
  /**
   * Listing负责人的FNSKU 比较(startswith)
   */
  private String listingHeadFnskuStartswith;
  /**
   * Listing负责人的FNSKU 比较(endswith)
   */
  private String listingHeadFnskuEndswith;
  /**
   * Listing负责人的FNSKU 比较(isnull)
   */
  private Boolean listingHeadFnskuIsnull;
  /**
   * Listing负责人的FNSKU 比较(isnotnull)
   */
  private Boolean listingHeadFnskuIsnotnull;

  /**
   * Listing负责人(范围搜索)
   */
  private List<Long> listingHeadInList;

  /**
   * 可用量
   */
  private Integer availbleNum;

  /**
   * 最小可用量
   */
  private Integer availbleNumMin;

  /**
   * 最大可用量
   */
  private Integer availbleNumMax;

  /**
   * 可用量 比较(eq)
   */
  private Integer availbleNumEq;
  /**
   * 可用量 比较(neq)
   */
  private Integer availbleNumNeq;
  /**
   * 可用量 比较(gt)
   */
  private Integer availbleNumGt;
  /**
   * 可用量 比较(gte)
   */
  private Integer availbleNumGte;
  /**
   * 可用量 比较(lt)
   */
  private Integer availbleNumLt;
  /**
   * 可用量 比较(lte)
   */
  private Integer availbleNumLte;
  /**
   * 可用量 比较(contains)
   */
  private Integer availbleNumContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Integer availbleNumNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Integer availbleNumStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Integer availbleNumEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean availbleNumIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean availbleNumIsnotnull;

  /**
   * 可用锁定量
   */
  private Integer locksAvailableAmount;

  /**
   * 最小可用锁定量
   */
  private Integer locksAvailableAmountMin;

  /**
   * 最大可用锁定量
   */
  private Integer locksAvailableAmountMax;

  /**
   * 可用锁定量 比较(eq)
   */
  private Integer locksAvailableAmountEq;
  /**
   * 可用锁定量 比较(neq)
   */
  private Integer locksAvailableAmountNeq;
  /**
   * 可用锁定量 比较(gt)
   */
  private Integer locksAvailableAmountGt;
  /**
   * 可用锁定量 比较(gte)
   */
  private Integer locksAvailableAmountGte;
  /**
   * 可用锁定量 比较(lt)
   */
  private Integer locksAvailableAmountLt;
  /**
   * 可用锁定量 比较(lte)
   */
  private Integer locksAvailableAmountLte;
  /**
   * 可用锁定量 比较(contains)
   */
  private Integer locksAvailableAmountContains;
  /**
   * 可用锁定量 比较(notcontains)
   */
  private Integer locksAvailableAmountNotcontains;
  /**
   * 可用锁定量 比较(startswith)
   */
  private Integer locksAvailableAmountStartswith;
  /**
   * 可用锁定量 比较(endswith)
   */
  private Integer locksAvailableAmountEndswith;
  /**
   * 可用锁定量 比较(isnull)
   */
  private Boolean locksAvailableAmountIsnull;
  /**
   * 可用锁定量 比较(isnotnull)
   */
  private Boolean locksAvailableAmountIsnotnull;

  /**
   * 次品量
   */
  private Integer defectiveQuantity;

  /**
   * 最小次品量
   */
  private Integer defectiveQuantityMin;

  /**
   * 最大次品量
   */
  private Integer defectiveQuantityMax;

  /**
   * 次品量 比较(eq)
   */
  private Integer defectiveQuantityEq;
  /**
   * 次品量 比较(neq)
   */
  private Integer defectiveQuantityNeq;
  /**
   * 次品量 比较(gt)
   */
  private Integer defectiveQuantityGt;
  /**
   * 次品量 比较(gte)
   */
  private Integer defectiveQuantityGte;
  /**
   * 次品量 比较(lt)
   */
  private Integer defectiveQuantityLt;
  /**
   * 次品量 比较(lte)
   */
  private Integer defectiveQuantityLte;
  /**
   * 次品量 比较(contains)
   */
  private Integer defectiveQuantityContains;
  /**
   * 次品量 比较(notcontains)
   */
  private Integer defectiveQuantityNotcontains;
  /**
   * 次品量 比较(startswith)
   */
  private Integer defectiveQuantityStartswith;
  /**
   * 次品量 比较(endswith)
   */
  private Integer defectiveQuantityEndswith;
  /**
   * 次品量 比较(isnull)
   */
  private Boolean defectiveQuantityIsnull;
  /**
   * 次品量 比较(isnotnull)
   */
  private Boolean defectiveQuantityIsnotnull;

  /**
   * 次品锁定量
   */
  private Integer defectiveLockAmount;

  /**
   * 最小次品锁定量
   */
  private Integer defectiveLockAmountMin;

  /**
   * 最大次品锁定量
   */
  private Integer defectiveLockAmountMax;

  /**
   * 次品锁定量 比较(eq)
   */
  private Integer defectiveLockAmountEq;
  /**
   * 次品锁定量 比较(neq)
   */
  private Integer defectiveLockAmountNeq;
  /**
   * 次品锁定量 比较(gt)
   */
  private Integer defectiveLockAmountGt;
  /**
   * 次品锁定量 比较(gte)
   */
  private Integer defectiveLockAmountGte;
  /**
   * 次品锁定量 比较(lt)
   */
  private Integer defectiveLockAmountLt;
  /**
   * 次品锁定量 比较(lte)
   */
  private Integer defectiveLockAmountLte;
  /**
   * 次品锁定量 比较(contains)
   */
  private Integer defectiveLockAmountContains;
  /**
   * 次品锁定量 比较(notcontains)
   */
  private Integer defectiveLockAmountNotcontains;
  /**
   * 次品锁定量 比较(startswith)
   */
  private Integer defectiveLockAmountStartswith;
  /**
   * 次品锁定量 比较(endswith)
   */
  private Integer defectiveLockAmountEndswith;
  /**
   * 次品锁定量 比较(isnull)
   */
  private Boolean defectiveLockAmountIsnull;
  /**
   * 次品锁定量 比较(isnotnull)
   */
  private Boolean defectiveLockAmountIsnotnull;

  /**
   * 预锁定量
   */
  private Integer preLockAmount;

  /**
   * 最小预锁定量
   */
  private Integer preLockAmountMin;

  /**
   * 最大预锁定量
   */
  private Integer preLockAmountMax;

  /**
   * 预锁定量 比较(eq)
   */
  private Integer preLockAmountEq;
  /**
   * 预锁定量 比较(neq)
   */
  private Integer preLockAmountNeq;
  /**
   * 预锁定量 比较(gt)
   */
  private Integer preLockAmountGt;
  /**
   * 预锁定量 比较(gte)
   */
  private Integer preLockAmountGte;
  /**
   * 预锁定量 比较(lt)
   */
  private Integer preLockAmountLt;
  /**
   * 预锁定量 比较(lte)
   */
  private Integer preLockAmountLte;
  /**
   * 预锁定量 比较(contains)
   */
  private Integer preLockAmountContains;
  /**
   * 预锁定量 比较(notcontains)
   */
  private Integer preLockAmountNotcontains;
  /**
   * 预锁定量 比较(startswith)
   */
  private Integer preLockAmountStartswith;
  /**
   * 预锁定量 比较(endswith)
   */
  private Integer preLockAmountEndswith;
  /**
   * 预锁定量 比较(isnull)
   */
  private Boolean preLockAmountIsnull;
  /**
   * 预锁定量 比较(isnotnull)
   */
  private Boolean preLockAmountIsnotnull;

  /**
   * 待检待上架量
   */
  private Integer inspected;

  /**
   * 最小待检待上架量
   */
  private Integer inspectedMin;

  /**
   * 最大待检待上架量
   */
  private Integer inspectedMax;

  /**
   * 待检待上架量 比较(eq)
   */
  private Integer inspectedEq;
  /**
   * 待检待上架量 比较(neq)
   */
  private Integer inspectedNeq;
  /**
   * 待检待上架量 比较(gt)
   */
  private Integer inspectedGt;
  /**
   * 待检待上架量 比较(gte)
   */
  private Integer inspectedGte;
  /**
   * 待检待上架量 比较(lt)
   */
  private Integer inspectedLt;
  /**
   * 待检待上架量 比较(lte)
   */
  private Integer inspectedLte;
  /**
   * 待检待上架量 比较(contains)
   */
  private Integer inspectedContains;
  /**
   * 待检待上架量 比较(notcontains)
   */
  private Integer inspectedNotcontains;
  /**
   * 待检待上架量 比较(startswith)
   */
  private Integer inspectedStartswith;
  /**
   * 待检待上架量 比较(endswith)
   */
  private Integer inspectedEndswith;
  /**
   * 待检待上架量 比较(isnull)
   */
  private Boolean inspectedIsnull;
  /**
   * 待检待上架量 比较(isnotnull)
   */
  private Boolean inspectedIsnotnull;

  /**
   * 待到货量
   */
  private Integer wait;

  /**
   * 最小待到货量
   */
  private Integer waitMin;

  /**
   * 最大待到货量
   */
  private Integer waitMax;

  /**
   * 待到货量 比较(eq)
   */
  private Integer waitEq;
  /**
   * 待到货量 比较(neq)
   */
  private Integer waitNeq;
  /**
   * 待到货量 比较(gt)
   */
  private Integer waitGt;
  /**
   * 待到货量 比较(gte)
   */
  private Integer waitGte;
  /**
   * 待到货量 比较(lt)
   */
  private Integer waitLt;
  /**
   * 待到货量 比较(lte)
   */
  private Integer waitLte;
  /**
   * 待到货量 比较(contains)
   */
  private Integer waitContains;
  /**
   * 待到货量 比较(notcontains)
   */
  private Integer waitNotcontains;
  /**
   * 待到货量 比较(startswith)
   */
  private Integer waitStartswith;
  /**
   * 待到货量 比较(endswith)
   */
  private Integer waitEndswith;
  /**
   * 待到货量 比较(isnull)
   */
  private Boolean waitIsnull;
  /**
   * 待到货量 比较(isnotnull)
   */
  private Boolean waitIsnotnull;

  /**
   * 期望可用量
   */
  private Integer expectAmount;

  /**
   * 最小期望可用量
   */
  private Integer expectAmountMin;

  /**
   * 最大期望可用量
   */
  private Integer expectAmountMax;

  /**
   * 期望可用量 比较(eq)
   */
  private Integer expectAmountEq;
  /**
   * 期望可用量 比较(neq)
   */
  private Integer expectAmountNeq;
  /**
   * 期望可用量 比较(gt)
   */
  private Integer expectAmountGt;
  /**
   * 期望可用量 比较(gte)
   */
  private Integer expectAmountGte;
  /**
   * 期望可用量 比较(lt)
   */
  private Integer expectAmountLt;
  /**
   * 期望可用量 比较(lte)
   */
  private Integer expectAmountLte;
  /**
   * 期望可用量 比较(contains)
   */
  private Integer expectAmountContains;
  /**
   * 期望可用量 比较(notcontains)
   */
  private Integer expectAmountNotcontains;
  /**
   * 期望可用量 比较(startswith)
   */
  private Integer expectAmountStartswith;
  /**
   * 期望可用量 比较(endswith)
   */
  private Integer expectAmountEndswith;
  /**
   * 期望可用量 比较(isnull)
   */
  private Boolean expectAmountIsnull;
  /**
   * 期望可用量 比较(isnotnull)
   */
  private Boolean expectAmountIsnotnull;

  /**
   * 期望待到货量
   */
  private Integer expectArrive;

  /**
   * 最小期望待到货量
   */
  private Integer expectArriveMin;

  /**
   * 最大期望待到货量
   */
  private Integer expectArriveMax;

  /**
   * 期望待到货量 比较(eq)
   */
  private Integer expectArriveEq;
  /**
   * 期望待到货量 比较(neq)
   */
  private Integer expectArriveNeq;
  /**
   * 期望待到货量 比较(gt)
   */
  private Integer expectArriveGt;
  /**
   * 期望待到货量 比较(gte)
   */
  private Integer expectArriveGte;
  /**
   * 期望待到货量 比较(lt)
   */
  private Integer expectArriveLt;
  /**
   * 期望待到货量 比较(lte)
   */
  private Integer expectArriveLte;
  /**
   * 期望待到货量 比较(contains)
   */
  private Integer expectArriveContains;
  /**
   * 期望待到货量 比较(notcontains)
   */
  private Integer expectArriveNotcontains;
  /**
   * 期望待到货量 比较(startswith)
   */
  private Integer expectArriveStartswith;
  /**
   * 期望待到货量 比较(endswith)
   */
  private Integer expectArriveEndswith;
  /**
   * 期望待到货量 比较(isnull)
   */
  private Boolean expectArriveIsnull;
  /**
   * 期望待到货量 比较(isnotnull)
   */
  private Boolean expectArriveIsnotnull;

  /**
   * 调拨在途
   */
  private Integer transfer;

  /**
   * 最小调拨在途
   */
  private Integer transferMin;

  /**
   * 最大调拨在途
   */
  private Integer transferMax;

  /**
   * 调拨在途 比较(eq)
   */
  private Integer transferEq;
  /**
   * 调拨在途 比较(neq)
   */
  private Integer transferNeq;
  /**
   * 调拨在途 比较(gt)
   */
  private Integer transferGt;
  /**
   * 调拨在途 比较(gte)
   */
  private Integer transferGte;
  /**
   * 调拨在途 比较(lt)
   */
  private Integer transferLt;
  /**
   * 调拨在途 比较(lte)
   */
  private Integer transferLte;
  /**
   * 调拨在途 比较(contains)
   */
  private Integer transferContains;
  /**
   * 调拨在途 比较(notcontains)
   */
  private Integer transferNotcontains;
  /**
   * 调拨在途 比较(startswith)
   */
  private Integer transferStartswith;
  /**
   * 调拨在途 比较(endswith)
   */
  private Integer transferEndswith;
  /**
   * 调拨在途 比较(isnull)
   */
  private Boolean transferIsnull;
  /**
   * 调拨在途 比较(isnotnull)
   */
  private Boolean transferIsnotnull;

  /**
   * 移除在途
   */
  private Integer removeProgress;

  /**
   * 最小移除在途
   */
  private Integer removeProgressMin;

  /**
   * 最大移除在途
   */
  private Integer removeProgressMax;

  /**
   * 移除在途 比较(eq)
   */
  private Integer removeProgressEq;
  /**
   * 移除在途 比较(neq)
   */
  private Integer removeProgressNeq;
  /**
   * 移除在途 比较(gt)
   */
  private Integer removeProgressGt;
  /**
   * 移除在途 比较(gte)
   */
  private Integer removeProgressGte;
  /**
   * 移除在途 比较(lt)
   */
  private Integer removeProgressLt;
  /**
   * 移除在途 比较(lte)
   */
  private Integer removeProgressLte;
  /**
   * 移除在途 比较(contains)
   */
  private Integer removeProgressContains;
  /**
   * 移除在途 比较(notcontains)
   */
  private Integer removeProgressNotcontains;
  /**
   * 移除在途 比较(startswith)
   */
  private Integer removeProgressStartswith;
  /**
   * 移除在途 比较(endswith)
   */
  private Integer removeProgressEndswith;
  /**
   * 移除在途 比较(isnull)
   */
  private Boolean removeProgressIsnull;
  /**
   * 移除在途 比较(isnotnull)
   */
  private Boolean removeProgressIsnotnull;

  /**
   * 实际总量
   */
  private Integer actualTotal;

  /**
   * 最小实际总量
   */
  private Integer actualTotalMin;

  /**
   * 最大实际总量
   */
  private Integer actualTotalMax;

  /**
   * 实际总量 比较(eq)
   */
  private Integer actualTotalEq;
  /**
   * 实际总量 比较(neq)
   */
  private Integer actualTotalNeq;
  /**
   * 实际总量 比较(gt)
   */
  private Integer actualTotalGt;
  /**
   * 实际总量 比较(gte)
   */
  private Integer actualTotalGte;
  /**
   * 实际总量 比较(lt)
   */
  private Integer actualTotalLt;
  /**
   * 实际总量 比较(lte)
   */
  private Integer actualTotalLte;
  /**
   * 实际总量 比较(contains)
   */
  private Integer actualTotalContains;
  /**
   * 实际总量 比较(notcontains)
   */
  private Integer actualTotalNotcontains;
  /**
   * 实际总量 比较(startswith)
   */
  private Integer actualTotalStartswith;
  /**
   * 实际总量 比较(endswith)
   */
  private Integer actualTotalEndswith;
  /**
   * 实际总量 比较(isnull)
   */
  private Boolean actualTotalIsnull;
  /**
   * 实际总量 比较(isnotnull)
   */
  private Boolean actualTotalIsnotnull;

  /**
   * 预计总量
   */
  private Integer estimatedTotal;

  /**
   * 最小预计总量
   */
  private Integer estimatedTotalMin;

  /**
   * 最大预计总量
   */
  private Integer estimatedTotalMax;

  /**
   * 预计总量 比较(eq)
   */
  private Integer estimatedTotalEq;
  /**
   * 预计总量 比较(neq)
   */
  private Integer estimatedTotalNeq;
  /**
   * 预计总量 比较(gt)
   */
  private Integer estimatedTotalGt;
  /**
   * 预计总量 比较(gte)
   */
  private Integer estimatedTotalGte;
  /**
   * 预计总量 比较(lt)
   */
  private Integer estimatedTotalLt;
  /**
   * 预计总量 比较(lte)
   */
  private Integer estimatedTotalLte;
  /**
   * 预计总量 比较(contains)
   */
  private Integer estimatedTotalContains;
  /**
   * 预计总量 比较(notcontains)
   */
  private Integer estimatedTotalNotcontains;
  /**
   * 预计总量 比较(startswith)
   */
  private Integer estimatedTotalStartswith;
  /**
   * 预计总量 比较(endswith)
   */
  private Integer estimatedTotalEndswith;
  /**
   * 预计总量 比较(isnull)
   */
  private Boolean estimatedTotalIsnull;
  /**
   * 预计总量 比较(isnotnull)
   */
  private Boolean estimatedTotalIsnotnull;

  /**
   * 采购单价
   */
  private java.math.BigDecimal purchasePrice;

  /**
   * 最小采购单价
   */
  private java.math.BigDecimal purchasePriceMin;

  /**
   * 最大采购单价
   */
  private java.math.BigDecimal purchasePriceMax;

  /**
   * 采购单价 比较(eq)
   */
  private java.math.BigDecimal purchasePriceEq;
  /**
   * 采购单价 比较(neq)
   */
  private java.math.BigDecimal purchasePriceNeq;
  /**
   * 采购单价 比较(gt)
   */
  private java.math.BigDecimal purchasePriceGt;
  /**
   * 采购单价 比较(gte)
   */
  private java.math.BigDecimal purchasePriceGte;
  /**
   * 采购单价 比较(lt)
   */
  private java.math.BigDecimal purchasePriceLt;
  /**
   * 采购单价 比较(lte)
   */
  private java.math.BigDecimal purchasePriceLte;
  /**
   * 采购单价 比较(contains)
   */
  private java.math.BigDecimal purchasePriceContains;
  /**
   * 采购单价 比较(notcontains)
   */
  private java.math.BigDecimal purchasePriceNotcontains;
  /**
   * 采购单价 比较(startswith)
   */
  private java.math.BigDecimal purchasePriceStartswith;
  /**
   * 采购单价 比较(endswith)
   */
  private java.math.BigDecimal purchasePriceEndswith;
  /**
   * 采购单价 比较(isnull)
   */
  private Boolean purchasePriceIsnull;
  /**
   * 采购单价 比较(isnotnull)
   */
  private Boolean purchasePriceIsnotnull;

  /**
   * 单位费用
   */
  private java.math.BigDecimal unitCosts;

  /**
   * 最小单位费用
   */
  private java.math.BigDecimal unitCostsMin;

  /**
   * 最大单位费用
   */
  private java.math.BigDecimal unitCostsMax;

  /**
   * 单位费用 比较(eq)
   */
  private java.math.BigDecimal unitCostsEq;
  /**
   * 单位费用 比较(neq)
   */
  private java.math.BigDecimal unitCostsNeq;
  /**
   * 单位费用 比较(gt)
   */
  private java.math.BigDecimal unitCostsGt;
  /**
   * 单位费用 比较(gte)
   */
  private java.math.BigDecimal unitCostsGte;
  /**
   * 单位费用 比较(lt)
   */
  private java.math.BigDecimal unitCostsLt;
  /**
   * 单位费用 比较(lte)
   */
  private java.math.BigDecimal unitCostsLte;
  /**
   * 单位费用 比较(contains)
   */
  private java.math.BigDecimal unitCostsContains;
  /**
   * 单位费用 比较(notcontains)
   */
  private java.math.BigDecimal unitCostsNotcontains;
  /**
   * 单位费用 比较(startswith)
   */
  private java.math.BigDecimal unitCostsStartswith;
  /**
   * 单位费用 比较(endswith)
   */
  private java.math.BigDecimal unitCostsEndswith;
  /**
   * 单位费用 比较(isnull)
   */
  private Boolean unitCostsIsnull;
  /**
   * 单位费用 比较(isnotnull)
   */
  private Boolean unitCostsIsnotnull;

  /**
   * 单位头程
   */
  private java.math.BigDecimal unitHeadStroke;

  /**
   * 最小单位头程
   */
  private java.math.BigDecimal unitHeadStrokeMin;

  /**
   * 最大单位头程
   */
  private java.math.BigDecimal unitHeadStrokeMax;

  /**
   * 单位头程 比较(eq)
   */
  private java.math.BigDecimal unitHeadStrokeEq;
  /**
   * 单位头程 比较(neq)
   */
  private java.math.BigDecimal unitHeadStrokeNeq;
  /**
   * 单位头程 比较(gt)
   */
  private java.math.BigDecimal unitHeadStrokeGt;
  /**
   * 单位头程 比较(gte)
   */
  private java.math.BigDecimal unitHeadStrokeGte;
  /**
   * 单位头程 比较(lt)
   */
  private java.math.BigDecimal unitHeadStrokeLt;
  /**
   * 单位头程 比较(lte)
   */
  private java.math.BigDecimal unitHeadStrokeLte;
  /**
   * 单位头程 比较(contains)
   */
  private java.math.BigDecimal unitHeadStrokeContains;
  /**
   * 单位头程 比较(notcontains)
   */
  private java.math.BigDecimal unitHeadStrokeNotcontains;
  /**
   * 单位头程 比较(startswith)
   */
  private java.math.BigDecimal unitHeadStrokeStartswith;
  /**
   * 单位头程 比较(endswith)
   */
  private java.math.BigDecimal unitHeadStrokeEndswith;
  /**
   * 单位头程 比较(isnull)
   */
  private Boolean unitHeadStrokeIsnull;
  /**
   * 单位头程 比较(isnotnull)
   */
  private Boolean unitHeadStrokeIsnotnull;

  /**
   * 单位库存成本
   */
  private java.math.BigDecimal unitInventoryCost;

  /**
   * 最小单位库存成本
   */
  private java.math.BigDecimal unitInventoryCostMin;

  /**
   * 最大单位库存成本
   */
  private java.math.BigDecimal unitInventoryCostMax;

  /**
   * 单位库存成本 比较(eq)
   */
  private java.math.BigDecimal unitInventoryCostEq;
  /**
   * 单位库存成本 比较(neq)
   */
  private java.math.BigDecimal unitInventoryCostNeq;
  /**
   * 单位库存成本 比较(gt)
   */
  private java.math.BigDecimal unitInventoryCostGt;
  /**
   * 单位库存成本 比较(gte)
   */
  private java.math.BigDecimal unitInventoryCostGte;
  /**
   * 单位库存成本 比较(lt)
   */
  private java.math.BigDecimal unitInventoryCostLt;
  /**
   * 单位库存成本 比较(lte)
   */
  private java.math.BigDecimal unitInventoryCostLte;
  /**
   * 单位库存成本 比较(contains)
   */
  private java.math.BigDecimal unitInventoryCostContains;
  /**
   * 单位库存成本 比较(notcontains)
   */
  private java.math.BigDecimal unitInventoryCostNotcontains;
  /**
   * 单位库存成本 比较(startswith)
   */
  private java.math.BigDecimal unitInventoryCostStartswith;
  /**
   * 单位库存成本 比较(endswith)
   */
  private java.math.BigDecimal unitInventoryCostEndswith;
  /**
   * 单位库存成本 比较(isnull)
   */
  private Boolean unitInventoryCostIsnull;
  /**
   * 单位库存成本 比较(isnotnull)
   */
  private Boolean unitInventoryCostIsnotnull;

  /**
   * 货值
   */
  private java.math.BigDecimal goodsValue;

  /**
   * 最小货值
   */
  private java.math.BigDecimal goodsValueMin;

  /**
   * 最大货值
   */
  private java.math.BigDecimal goodsValueMax;

  /**
   * 货值 比较(eq)
   */
  private java.math.BigDecimal goodsValueEq;
  /**
   * 货值 比较(neq)
   */
  private java.math.BigDecimal goodsValueNeq;
  /**
   * 货值 比较(gt)
   */
  private java.math.BigDecimal goodsValueGt;
  /**
   * 货值 比较(gte)
   */
  private java.math.BigDecimal goodsValueGte;
  /**
   * 货值 比较(lt)
   */
  private java.math.BigDecimal goodsValueLt;
  /**
   * 货值 比较(lte)
   */
  private java.math.BigDecimal goodsValueLte;
  /**
   * 货值 比较(contains)
   */
  private java.math.BigDecimal goodsValueContains;
  /**
   * 货值 比较(notcontains)
   */
  private java.math.BigDecimal goodsValueNotcontains;
  /**
   * 货值 比较(startswith)
   */
  private java.math.BigDecimal goodsValueStartswith;
  /**
   * 货值 比较(endswith)
   */
  private java.math.BigDecimal goodsValueEndswith;
  /**
   * 货值 比较(isnull)
   */
  private Boolean goodsValueIsnull;
  /**
   * 货值 比较(isnotnull)
   */
  private Boolean goodsValueIsnotnull;

  /**
   * 费用
   */
  private java.math.BigDecimal expenses;

  /**
   * 最小费用
   */
  private java.math.BigDecimal expensesMin;

  /**
   * 最大费用
   */
  private java.math.BigDecimal expensesMax;

  /**
   * 费用 比较(eq)
   */
  private java.math.BigDecimal expensesEq;
  /**
   * 费用 比较(neq)
   */
  private java.math.BigDecimal expensesNeq;
  /**
   * 费用 比较(gt)
   */
  private java.math.BigDecimal expensesGt;
  /**
   * 费用 比较(gte)
   */
  private java.math.BigDecimal expensesGte;
  /**
   * 费用 比较(lt)
   */
  private java.math.BigDecimal expensesLt;
  /**
   * 费用 比较(lte)
   */
  private java.math.BigDecimal expensesLte;
  /**
   * 费用 比较(contains)
   */
  private java.math.BigDecimal expensesContains;
  /**
   * 费用 比较(notcontains)
   */
  private java.math.BigDecimal expensesNotcontains;
  /**
   * 费用 比较(startswith)
   */
  private java.math.BigDecimal expensesStartswith;
  /**
   * 费用 比较(endswith)
   */
  private java.math.BigDecimal expensesEndswith;
  /**
   * 费用 比较(isnull)
   */
  private Boolean expensesIsnull;
  /**
   * 费用 比较(isnotnull)
   */
  private Boolean expensesIsnotnull;

  /**
   * 头程
   */
  private java.math.BigDecimal headStroke;

  /**
   * 最小头程
   */
  private java.math.BigDecimal headStrokeMin;

  /**
   * 最大头程
   */
  private java.math.BigDecimal headStrokeMax;

  /**
   * 头程 比较(eq)
   */
  private java.math.BigDecimal headStrokeEq;
  /**
   * 头程 比较(neq)
   */
  private java.math.BigDecimal headStrokeNeq;
  /**
   * 头程 比较(gt)
   */
  private java.math.BigDecimal headStrokeGt;
  /**
   * 头程 比较(gte)
   */
  private java.math.BigDecimal headStrokeGte;
  /**
   * 头程 比较(lt)
   */
  private java.math.BigDecimal headStrokeLt;
  /**
   * 头程 比较(lte)
   */
  private java.math.BigDecimal headStrokeLte;
  /**
   * 头程 比较(contains)
   */
  private java.math.BigDecimal headStrokeContains;
  /**
   * 头程 比较(notcontains)
   */
  private java.math.BigDecimal headStrokeNotcontains;
  /**
   * 头程 比较(startswith)
   */
  private java.math.BigDecimal headStrokeStartswith;
  /**
   * 头程 比较(endswith)
   */
  private java.math.BigDecimal headStrokeEndswith;
  /**
   * 头程 比较(isnull)
   */
  private Boolean headStrokeIsnull;
  /**
   * 头程 比较(isnotnull)
   */
  private Boolean headStrokeIsnotnull;

  /**
   * 库存成本
   */
  private java.math.BigDecimal inventoryCost;

  /**
   * 最小库存成本
   */
  private java.math.BigDecimal inventoryCostMin;

  /**
   * 最大库存成本
   */
  private java.math.BigDecimal inventoryCostMax;

  /**
   * 库存成本 比较(eq)
   */
  private java.math.BigDecimal inventoryCostEq;
  /**
   * 库存成本 比较(neq)
   */
  private java.math.BigDecimal inventoryCostNeq;
  /**
   * 库存成本 比较(gt)
   */
  private java.math.BigDecimal inventoryCostGt;
  /**
   * 库存成本 比较(gte)
   */
  private java.math.BigDecimal inventoryCostGte;
  /**
   * 库存成本 比较(lt)
   */
  private java.math.BigDecimal inventoryCostLt;
  /**
   * 库存成本 比较(lte)
   */
  private java.math.BigDecimal inventoryCostLte;
  /**
   * 库存成本 比较(contains)
   */
  private java.math.BigDecimal inventoryCostContains;
  /**
   * 库存成本 比较(notcontains)
   */
  private java.math.BigDecimal inventoryCostNotcontains;
  /**
   * 库存成本 比较(startswith)
   */
  private java.math.BigDecimal inventoryCostStartswith;
  /**
   * 库存成本 比较(endswith)
   */
  private java.math.BigDecimal inventoryCostEndswith;
  /**
   * 库存成本 比较(isnull)
   */
  private Boolean inventoryCostIsnull;
  /**
   * 库存成本 比较(isnotnull)
   */
  private Boolean inventoryCostIsnotnull;

  /**
   * 平均库龄
   */
  private Integer averageInventoryAge;

  /**
   * 最小平均库龄
   */
  private Integer averageInventoryAgeMin;

  /**
   * 最大平均库龄
   */
  private Integer averageInventoryAgeMax;

  /**
   * 平均库龄 比较(eq)
   */
  private Integer averageInventoryAgeEq;
  /**
   * 平均库龄 比较(neq)
   */
  private Integer averageInventoryAgeNeq;
  /**
   * 平均库龄 比较(gt)
   */
  private Integer averageInventoryAgeGt;
  /**
   * 平均库龄 比较(gte)
   */
  private Integer averageInventoryAgeGte;
  /**
   * 平均库龄 比较(lt)
   */
  private Integer averageInventoryAgeLt;
  /**
   * 平均库龄 比较(lte)
   */
  private Integer averageInventoryAgeLte;
  /**
   * 平均库龄 比较(contains)
   */
  private Integer averageInventoryAgeContains;
  /**
   * 平均库龄 比较(notcontains)
   */
  private Integer averageInventoryAgeNotcontains;
  /**
   * 平均库龄 比较(startswith)
   */
  private Integer averageInventoryAgeStartswith;
  /**
   * 平均库龄 比较(endswith)
   */
  private Integer averageInventoryAgeEndswith;
  /**
   * 平均库龄 比较(isnull)
   */
  private Boolean averageInventoryAgeIsnull;
  /**
   * 平均库龄 比较(isnotnull)
   */
  private Boolean averageInventoryAgeIsnotnull;

  /**
   * 预警状态(模糊搜索)
   */
  private String alertStatus;

  /**
   * 预警状态 比较(eq)
   */
  private String alertStatusEq;
  /**
   * 预警状态 比较(neq)
   */
  private String alertStatusNeq;
  /**
   * 预警状态 比较(gt)
   */
  private String alertStatusGt;
  /**
   * 预警状态 比较(gte)
   */
  private String alertStatusGte;
  /**
   * 预警状态 比较(lt)
   */
  private String alertStatusLt;
  /**
   * 预警状态 比较(lte)
   */
  private String alertStatusLte;
  /**
   * 预警状态 比较(contains)
   */
  private String alertStatusContains;
  /**
   * 预警状态 比较(notcontains)
   */
  private String alertStatusNotcontains;
  /**
   * 预警状态 比较(startswith)
   */
  private String alertStatusStartswith;
  /**
   * 预警状态 比较(endswith)
   */
  private String alertStatusEndswith;
  /**
   * 预警状态 比较(isnull)
   */
  private Boolean alertStatusIsnull;
  /**
   * 预警状态 比较(isnotnull)
   */
  private Boolean alertStatusIsnotnull;

  /**
   * 预警状态(精确搜索)
   */
  private List<String> alertStatusInList;

  /**
   * 0-15天库龄(模糊搜索)
   */
  private String age0;

  /**
   * 0-15天库龄 比较(eq)
   */
  private String age0Eq;
  /**
   * 0-15天库龄 比较(neq)
   */
  private String age0Neq;
  /**
   * 0-15天库龄 比较(gt)
   */
  private String age0Gt;
  /**
   * 0-15天库龄 比较(gte)
   */
  private String age0Gte;
  /**
   * 0-15天库龄 比较(lt)
   */
  private String age0Lt;
  /**
   * 0-15天库龄 比较(lte)
   */
  private String age0Lte;
  /**
   * 0-15天库龄 比较(contains)
   */
  private String age0Contains;
  /**
   * 0-15天库龄 比较(notcontains)
   */
  private String age0Notcontains;
  /**
   * 0-15天库龄 比较(startswith)
   */
  private String age0Startswith;
  /**
   * 0-15天库龄 比较(endswith)
   */
  private String age0Endswith;
  /**
   * 0-15天库龄 比较(isnull)
   */
  private Boolean age0Isnull;
  /**
   * 0-15天库龄 比较(isnotnull)
   */
  private Boolean age0Isnotnull;

  /**
   * 0-15天库龄(精确搜索)
   */
  private List<String> age0InList;

  /**
   * 16-30天库龄(模糊搜索)
   */
  private String age16;

  /**
   * 16-30天库龄 比较(eq)
   */
  private String age16Eq;
  /**
   * 16-30天库龄 比较(neq)
   */
  private String age16Neq;
  /**
   * 16-30天库龄 比较(gt)
   */
  private String age16Gt;
  /**
   * 16-30天库龄 比较(gte)
   */
  private String age16Gte;
  /**
   * 16-30天库龄 比较(lt)
   */
  private String age16Lt;
  /**
   * 16-30天库龄 比较(lte)
   */
  private String age16Lte;
  /**
   * 16-30天库龄 比较(contains)
   */
  private String age16Contains;
  /**
   * 16-30天库龄 比较(notcontains)
   */
  private String age16Notcontains;
  /**
   * 16-30天库龄 比较(startswith)
   */
  private String age16Startswith;
  /**
   * 16-30天库龄 比较(endswith)
   */
  private String age16Endswith;
  /**
   * 16-30天库龄 比较(isnull)
   */
  private Boolean age16Isnull;
  /**
   * 16-30天库龄 比较(isnotnull)
   */
  private Boolean age16Isnotnull;

  /**
   * 16-30天库龄(精确搜索)
   */
  private List<String> age16InList;

  /**
   * 31-90天库龄(模糊搜索)
   */
  private String age31;

  /**
   * 31-90天库龄 比较(eq)
   */
  private String age31Eq;
  /**
   * 31-90天库龄 比较(neq)
   */
  private String age31Neq;
  /**
   * 31-90天库龄 比较(gt)
   */
  private String age31Gt;
  /**
   * 31-90天库龄 比较(gte)
   */
  private String age31Gte;
  /**
   * 31-90天库龄 比较(lt)
   */
  private String age31Lt;
  /**
   * 31-90天库龄 比较(lte)
   */
  private String age31Lte;
  /**
   * 31-90天库龄 比较(contains)
   */
  private String age31Contains;
  /**
   * 31-90天库龄 比较(notcontains)
   */
  private String age31Notcontains;
  /**
   * 31-90天库龄 比较(startswith)
   */
  private String age31Startswith;
  /**
   * 31-90天库龄 比较(endswith)
   */
  private String age31Endswith;
  /**
   * 31-90天库龄 比较(isnull)
   */
  private Boolean age31Isnull;
  /**
   * 31-90天库龄 比较(isnotnull)
   */
  private Boolean age31Isnotnull;

  /**
   * 31-90天库龄(精确搜索)
   */
  private List<String> age31InList;

  /**
   * 91天以上库龄(模糊搜索)
   */
  private String age91;

  /**
   * 91天以上库龄 比较(eq)
   */
  private String age91Eq;
  /**
   * 91天以上库龄 比较(neq)
   */
  private String age91Neq;
  /**
   * 91天以上库龄 比较(gt)
   */
  private String age91Gt;
  /**
   * 91天以上库龄 比较(gte)
   */
  private String age91Gte;
  /**
   * 91天以上库龄 比较(lt)
   */
  private String age91Lt;
  /**
   * 91天以上库龄 比较(lte)
   */
  private String age91Lte;
  /**
   * 91天以上库龄 比较(contains)
   */
  private String age91Contains;
  /**
   * 91天以上库龄 比较(notcontains)
   */
  private String age91Notcontains;
  /**
   * 91天以上库龄 比较(startswith)
   */
  private String age91Startswith;
  /**
   * 91天以上库龄 比较(endswith)
   */
  private String age91Endswith;
  /**
   * 91天以上库龄 比较(isnull)
   */
  private Boolean age91Isnull;
  /**
   * 91天以上库龄 比较(isnotnull)
   */
  private Boolean age91Isnotnull;

  /**
   * 91天以上库龄(精确搜索)
   */
  private List<String> age91InList;

  /**
   * SPU
   */
  private Long spu;

  /**
   * SPU 比较(eq)
   */
  private Long spuEq;
  /**
   * SPU 比较(neq)
   */
  private Long spuNeq;
  /**
   * SPU 比较(gt)
   */
  private Long spuGt;
  /**
   * SPU 比较(gte)
   */
  private Long spuGte;
  /**
   * SPU 比较(lt)
   */
  private Long spuLt;
  /**
   * SPU 比较(lte)
   */
  private Long spuLte;
  /**
   * SPU 比较(contains)
   */
  private Long spuContains;
  /**
   * SPU 比较(notcontains)
   */
  private Long spuNotcontains;
  /**
   * SPU 比较(startswith)
   */
  private Long spuStartswith;
  /**
   * SPU 比较(endswith)
   */
  private Long spuEndswith;
  /**
   * SPU 比较(isnull)
   */
  private Boolean spuIsnull;
  /**
   * SPU 比较(isnotnull)
   */
  private Boolean spuIsnotnull;
  /**
   * SPU的品名 比较(eq)
   */
  private String spuNameEq;
  /**
   * SPU的品名 比较(neq)
   */
  private String spuNameNeq;
  /**
   * SPU的品名 比较(gt)
   */
  private String spuNameGt;
  /**
   * SPU的品名 比较(gte)
   */
  private String spuNameGte;
  /**
   * SPU的品名 比较(lt)
   */
  private String spuNameLt;
  /**
   * SPU的品名 比较(lte)
   */
  private String spuNameLte;
  /**
   * SPU的品名 比较(contains)
   */
  private String spuNameContains;
  /**
   * SPU的品名 比较(notcontains)
   */
  private String spuNameNotcontains;
  /**
   * SPU的品名 比较(startswith)
   */
  private String spuNameStartswith;
  /**
   * SPU的品名 比较(endswith)
   */
  private String spuNameEndswith;
  /**
   * SPU的品名 比较(isnull)
   */
  private Boolean spuNameIsnull;
  /**
   * SPU的品名 比较(isnotnull)
   */
  private Boolean spuNameIsnotnull;

  /**
   * SPU(范围搜索)
   */
  private List<Long> spuInList;

  /**
   * 是否有 图片
   */
  private Boolean img;

  /**
   * 仓位
   */
  private Long pos;

  /**
   * 仓位 比较(eq)
   */
  private Long posEq;
  /**
   * 仓位 比较(neq)
   */
  private Long posNeq;
  /**
   * 仓位 比较(gt)
   */
  private Long posGt;
  /**
   * 仓位 比较(gte)
   */
  private Long posGte;
  /**
   * 仓位 比较(lt)
   */
  private Long posLt;
  /**
   * 仓位 比较(lte)
   */
  private Long posLte;
  /**
   * 仓位 比较(contains)
   */
  private Long posContains;
  /**
   * 仓位 比较(notcontains)
   */
  private Long posNotcontains;
  /**
   * 仓位 比较(startswith)
   */
  private Long posStartswith;
  /**
   * 仓位 比较(endswith)
   */
  private Long posEndswith;
  /**
   * 仓位 比较(isnull)
   */
  private Boolean posIsnull;
  /**
   * 仓位 比较(isnotnull)
   */
  private Boolean posIsnotnull;
  /**
   * 仓位的仓位 比较(eq)
   */
  private String posStorageBinEq;
  /**
   * 仓位的仓位 比较(neq)
   */
  private String posStorageBinNeq;
  /**
   * 仓位的仓位 比较(gt)
   */
  private String posStorageBinGt;
  /**
   * 仓位的仓位 比较(gte)
   */
  private String posStorageBinGte;
  /**
   * 仓位的仓位 比较(lt)
   */
  private String posStorageBinLt;
  /**
   * 仓位的仓位 比较(lte)
   */
  private String posStorageBinLte;
  /**
   * 仓位的仓位 比较(contains)
   */
  private String posStorageBinContains;
  /**
   * 仓位的仓位 比较(notcontains)
   */
  private String posStorageBinNotcontains;
  /**
   * 仓位的仓位 比较(startswith)
   */
  private String posStorageBinStartswith;
  /**
   * 仓位的仓位 比较(endswith)
   */
  private String posStorageBinEndswith;
  /**
   * 仓位的仓位 比较(isnull)
   */
  private Boolean posStorageBinIsnull;
  /**
   * 仓位的仓位 比较(isnotnull)
   */
  private Boolean posStorageBinIsnotnull;

  /**
   * 仓位(范围搜索)
   */
  private List<Long> posInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
